package com.github.tvbox.osc.ui.activity;

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;

import com.github.tvbox.osc.R;
import com.github.tvbox.osc.base.App;
import com.github.tvbox.osc.base.BackHandlerHelper;
import com.github.tvbox.osc.base.BaseActivity;
import com.github.tvbox.osc.cache.VodCollect;
import com.github.tvbox.osc.event.PlayEvent;
import com.github.tvbox.osc.event.RefreshEvent;
import com.github.tvbox.osc.ui.activity.Media.MediaActionView;
import com.github.tvbox.osc.ui.activity.Media.MediaBaseView;
import com.github.tvbox.osc.ui.activity.Media.MediaPreview;
import com.github.tvbox.osc.ui.activity.Media.MediaVodPanelView;
import com.github.tvbox.osc.viewmodel.SourceViewModel;
import com.orhanobut.logger.Logger;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import androidx.lifecycle.ViewModelProvider;
import io.github.source.Source;
import io.github.source.bean.Site;
import io.github.source.config.VodConfig;
import io.github.source.media.bean.MediaBean;
import io.github.source.media.bean.MediaResult;

/**
 * 详情，播放，查看
 * 播放界面会由一个Fragment承载 1，减少Activity的代码复杂度，2，方便Fragment的复用
 */
public class DetailActivity extends BaseActivity {
    private static final String TAG = "APP.DetailActivity";
    private SourceViewModel mSourceViewModel;
    private MediaBean mediaBean;

    //UI===
    private MediaPreview mMediaPreview;
    private MediaVodPanelView mMediaVodPanelView;
    private MediaBaseView mMediaBase;
    private MediaActionView mMediaActionView;

    private final List<MediaBean> searchList = new ArrayList<>();
    /**
     * ID
     */
    public static String VOD_ID = "vodId";
    /**
     * 源站
     */
    public static String SITE_KEY = "siteKey";
    /**
     * 名称（关键字等）
     */
    public static String QUERY_WORD = "queryWord";


    /**
     * 跳转到媒体详情
     *
     * @param vodId   点播ID
     * @param siteKey 源站
     */
    public static void start(String vodId, String siteKey) {

        Intent intent = new Intent(App.getInstance(), DetailActivity.class);
        intent.putExtra(VOD_ID, vodId);
        intent.putExtra(SITE_KEY, siteKey);
        intent.putExtra(QUERY_WORD, "");/*名称（关键字等）*/

        Bundle bundle = new Bundle();
        bundle.putString(VOD_ID, vodId);
        bundle.putString(SITE_KEY, siteKey);
        bundle.putString(QUERY_WORD, "");
        intent.putExtras(bundle);

        App.getInstance().startActivity(intent);
    }

    @Override
    protected int getLayoutResID() {
        return R.layout.activity_detail_2;
    }

    @Override
    protected void init() {
        EventBus.getDefault().register(this);
        initView();
        initViewModel();
        initData();
    }

    private void initView() {
        View rootView = findViewById(R.id.root_view);
        mMediaBase = MediaBaseView.create(rootView);
        mMediaPreview = MediaPreview.create(rootView);
        mMediaActionView = MediaActionView.create(rootView);
        mMediaVodPanelView = MediaVodPanelView.create(rootView);

        /*-----点播面板-------*/
        mMediaVodPanelView.setOnFlagItemClickListener((adapter, view, position) -> {
            //ignore
        });
        mMediaVodPanelView.setOnSeriesItemClickListener((adapter, view, position) -> {
            startPlay();
        });
        /*--------快捷操作-------*/
        mMediaActionView.setActionListener((view, action) -> {
            switch (action) {
                case MediaActionView.ACTION_COLLECT:
                    insertVodCollect();
                    break;
                case MediaActionView.ACTION_QUICK_SEARCH:
                    jumpActivity(SearchActivity.class, new Bundle());
                    break;
                case MediaActionView.ACTION_SHARE:
                    Toast.makeText(DetailActivity.this, "分享", Toast.LENGTH_SHORT).show();
                    break;
                case MediaActionView.ACTION_SETTING:
                case MediaActionView.ACTION_SITE:
                    playNextSite();
                    break;
            }
        });
    }

    private void initViewModel() {
        mSourceViewModel = new ViewModelProvider(this).get(SourceViewModel.class);
        mSourceViewModel.MediaSearchResult.observe(this, this::setMediaSearchResult);
        mSourceViewModel.MediaDetailResult.observe(this, this::setMediaDetailsResult);
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        initData();
    }

    /**
     * 处理搜索结果
     *
     * @param result 结果
     */
    public void setMediaSearchResult(MediaResult<List<MediaBean>> result) {
        Logger.t(TAG).d("设置媒体搜索数据 " + result);
        /*
         *检查一结果，取有用的用来显示
         */
        //什么情况下该换下一下？
        if (result == null) {
            onTryNextSearchError();
            return;
        }
        List<MediaBean> mediaList = result.getData();
        if (mediaList == null || mediaList.isEmpty()) {
            onTryNextSearchError();
            return;
        }

        Iterator<MediaBean> iterator = mediaList.iterator();
        while (iterator.hasNext()) {
            if (mismatch(iterator.next())) iterator.remove();
        }
        searchList.addAll(mediaList);

        onNextSiteResult();
    }

    private void getDetail(MediaBean item) {
        setVodId(item.getVodId());
        setSiteKey(item.getSiteKey());
        getMediaDetail();
    }

    public void onNextSiteResult() {
        if (searchList.size() == 0) return;
        MediaBean item = searchList.get(0);// 获取第一个
        searchList.remove(item);
        getDetail(item);
    }

    private boolean mismatch(MediaBean mediaBean) {
        return false;
    }

    /**
     * 设置详情 1，详情描述，2点播详情 3，点播播放地址
     *
     * @param result 结果详情
     */
    public void setMediaDetailsResult(MediaResult<List<MediaBean>> result) {
        Logger.t(TAG).d("设置媒体详情数据。" + result);
        /*先检查：不符合时则重新刷新*/
        if (result == null) {
            showEmpty(); // 如果result为null，直接显示为空
            tryNextDetails();
            return;
        }
        List<MediaBean> mediaList = result.getData();
        if (mediaList == null || mediaList.isEmpty()) {
            showEmpty(); // 如果没有数据，显示为空
            tryNextDetails();
            return;
        }
        showSuccess();
        for (MediaBean mediaBean : mediaList) {
            if (mediaBean.getVodId() != null) {
                setMediaDetails(mediaBean);
                break;
            }
        }
    }

    public void setMediaDetails(MediaBean result) {
        // 在调用以下方法之前，建议增加对非空检查
        mediaBean = result;
        if (mediaBean != null) {
            mMediaBase.setMediaDetails(mediaBean);
            mMediaPreview.setMediaDetails(mediaBean);
            mMediaActionView.setMediaDetails(mediaBean);
            mMediaVodPanelView.setMediaVodPanel(mediaBean);
        }
        //保存信息
        if (mediaBean != null) {
            setVodId(mediaBean.getVodId());
            setSiteKey(mediaBean.getSiteKey());
            setKeyWord(mediaBean.getVodName());
        }
    }

    /**
     * 解析入参
     */
    private void initData() {
        Intent intent = getIntent();
        if (intent != null && intent.getExtras() != null) {
            Bundle bundle = intent.getExtras();
        }

        // #1前置检查：媒体是否可以播放
        if (isMediaReadyPlay()) {
            Logger.t(TAG).d("尝试播放媒体数据");
            tryToPlayMedia();
        }
        if (isShouldDetails()) {
            Logger.t(TAG).d("尝试获取播放媒体详情数据");
            getMediaDetail();
        }
        if (isShouldSearch()) {
            Logger.t(TAG).d("尝试获取播放媒体搜索数据");
            getMediaSearch();
        }

    }

    private void getMediaDetail() {
        String siteKey = getSiteKey("");
        String vodId = getVodId("");
        mSourceViewModel.fetchDetails(siteKey, vodId);
    }

    private void getMediaSearch() {
        String siteKey = getSiteKey("");
        String keyWord = getKeyWord("");
        mSourceViewModel.fetchSearch(siteKey, keyWord);
    }


    /**
     * 获取选中（集）的点播连接
     *
     * @return 点播连接 如果不存在，可能返回NULL
     */
    private String getVodUrl() {
        if (mMediaVodPanelView != null) {
            return mMediaVodPanelView.getEpisodeUrl();
        }
        return "";
    }

    public String getVodId() {
        if (mediaBean != null) {
            return mediaBean.getVodId();
        }
        String id = getVodId("");
        if (id != null) {
            return id;
        }
        return "";
    }

    private void startPlay() {
        if (mMediaPreview != null) {
            mMediaPreview.startPlay(mediaBean);
        }
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void refresh(RefreshEvent event) {
    }

    //======================

    @Override
    public void onBackPressed() {
        if (BackHandlerHelper.handleBackPress(this)) {
            return;
        }
        if (mMediaPreview.onBackPressed()) {
            return;
        }
        super.onBackPressed();
    }

    //处理搜索的结果（如果出错，则下一个搜索）
    private void onTryNextSearchError() {
        /*更换一个源站点*/
        Site site = getNextSite();
        if (site != null) {
            getMediaSearch(getSiteKey(""), getKeyWord(""));
        }
    }

    //切换一下源站点
    private void playNextSite() {
        //重新加载搜索
        try {
            //改变标签：再去加载播放信息
            Site site = getNextSite();//变更下一可用源站点
            if (site != null) {
                setSiteKey(site.getKey());
                setKeyWord(getKeyWord(""));
                setVodId("");
                getMediaSearch(site.getKey(), getKeyWord(""));//重新搜索
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //插入收藏
    private void insertVodCollect() {
        if (mediaBean != null) {
            VodCollect vodCollect = new VodCollect();
        }
    }

    /**
     * 获取当前的源站点信息
     *
     * @param siteKey 默认站点
     * @return 站点
     */
    private String getSiteKey(String siteKey) {
        try {
            return getIntent().getStringExtra(SITE_KEY);
        } catch (Exception e) {
            return siteKey;
        }
    }

    private void setSiteKey(String siteKey) {
        getIntent().putExtra(SITE_KEY, siteKey);
    }

    public String getKeyWord(String keyWord) {
        try {
            return getIntent().getStringExtra(QUERY_WORD);
        } catch (Exception e) {
            return keyWord;
        }
    }

    public void setKeyWord(String keyWord) {
        getIntent().putExtra(QUERY_WORD, keyWord);
    }

    /**
     * 获取得媒体ID
     *
     * @param vodId 媒体ID
     * @return 媒体ID
     */
    public String getVodId(String vodId) {
        return getIntent().getStringExtra(VOD_ID);
    }

    public void setVodId(String vodId) {
        getIntent().putExtra(VOD_ID, vodId);
    }


    /*可用使用的源站点*/
    public List<Site> vodSites = new ArrayList<>();

    public void setVodSites(List<Site> vodSites) {
        this.vodSites = vodSites;
    }

    /**
     * 获取所有源站列表
     *
     * @return 源站列表
     */
    public List<Site> getVodSites() {
        if (vodSites == null || vodSites.isEmpty()) {
            vodSites = VodConfig.get().getSites();
        }
        return vodSites;
    }

    private void getMediaSearch(String siteKey, String keyword) {
        try {
            mSourceViewModel.fetchSearch(siteKey, keyword);
        } catch (Throwable ignored) {
            ignored.printStackTrace();
        }
    }

    public String getQueryWord() {
        String searchTitle = mediaBean.getVodName();
        return searchTitle;
    }

    /**
     * 已经失效的
     */
    List<String> usedSitesKey = new ArrayList<>();
    private Site curSite;

    /**
     * *换下一个源站点
     *
     * @return 源站点
     */
    private Site getNextSite() {
        List<Site> sites = getVodSites();
        Site takeOne = null;
        for (Site bean : sites) {
            if (usedSitesKey.contains(bean.getKey())) {
                continue;
            }
            if (!bean.isSearchable()) {
                usedSitesKey.add(bean.getKey());
                continue;
            }

            takeOne = bean;
            usedSitesKey.add(bean.getKey());
            break;

        }

        if (takeOne != null) {
            setCurSite(takeOne);
            setSiteKey(takeOne.getKey());
        } else {
            setCurSite(null);
            setSiteKey(null);
        }

        return takeOne;
    }

    private void setCurSite(Site site) {
        curSite = site;
    }

    /**
     * 尝试执行播放当前的媒体 参见 {@link MediaBean}
     *
     * @return true 执行成功； false 没有执行
     */
    private boolean tryToPlayMedia() {
        try {
            //去播放
            mMediaPreview.startPlay(mediaBean);
            Logger.t(TAG).d("尝试播放媒体");
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 处理当前Activity的播放状态
     */
    private void handleThisMediaScreen() {


    }

    /**
     * 判断当前是不是符合播放条件
     * #1.存在播放信息；2.详情加载了吗；3.播放列表加载了吗；
     *
     * @return true 符合
     */
    private boolean isMediaReadyPlay() {
        /*有播放地址*/
        String playUrl = getVodUrl();
        if (playUrl == null || playUrl.isEmpty()) {
            return false;
        }
        //详情加载了吗？
        if (!isMediaDetailsReady()) {
            return false;
        }
        //播放列表加载了吗
        if (!isMediaPlayListReady()) {
            return false;
        }
        return true;
    }

    private boolean isMediaDetailsReady() {
        if (mediaBean == null) {
            return false;
        }
        try {
            return mMediaBase.isDetailsReady();
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    private boolean isMediaPlayListReady() {
        if (mediaBean == null) {
            return false;
        }
        try {
            if (mMediaVodPanelView == null) {
                return false;
            }
            return mMediaVodPanelView.isPlayListReady();
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 是不是需要获取搜索结果
     *
     * @return true 是需要搜索，false 不需要
     */
    public boolean isShouldSearch() {
        /*
         * 1,当前的源站是不是有效
         * 2,当前的搜索关键字是不是有效
         *
         */

        String siteKey = getSiteKey("");
        if (siteKey == null || siteKey.isEmpty()) {
            return false;
        }
        String keyWord = getKeyWord("");
        if (keyWord == null || keyWord.isEmpty()) {
            return false;
        }

        return true;
    }

    /**
     * 是不是需要获取详情
     *
     * @return true 是的
     */
    public boolean isShouldDetails() {
        String siteKey = getSiteKey("");
        if (siteKey == null || siteKey.isEmpty()) {
            return false;
        }
        String vodId = getVodId("");
        if (vodId == null || vodId.isEmpty()) {
            return false;
        }
        /*已经准备好了*/
        if (isMediaDetailsReady()) {
            return false;
        }
        return true;
    }

    public void tryNextDetails() {
        Site site = getNextSite();
        if (site != null) {
            setSiteKey(site.getKey());
        } else {
            setSiteKey("");
        }

        getMediaSearch();
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onPlayEvent(PlayEvent event) {
        if (event == PlayEvent.PLAY_ERROR) {
            /*播放出错了*/
            Toast.makeText(mContext, "播放出错了", Toast.LENGTH_SHORT).show();
        }
        if (mMediaVodPanelView != null) {
            mMediaVodPanelView.onPlayEvent(event);
        }
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        EventBus.getDefault().unregister(this);
        Source.get().stop();
    }
}